package utils;

import android.content.Context;
import android.graphics.Bitmap;
import android.text.TextUtils;
import android.view.View;
import android.widget.ImageView;

import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.target.GlideDrawableImageViewTarget;
import com.bumptech.glide.request.target.ImageViewTarget;
import com.nostra13.universalimageloader.core.DisplayImageOptions;
import com.nostra13.universalimageloader.core.ImageLoader;
import com.nostra13.universalimageloader.core.assist.ImageScaleType;
import com.nostra13.universalimageloader.core.imageaware.ImageAware;
import com.nostra13.universalimageloader.core.imageaware.ImageViewAware;
import com.nostra13.universalimageloader.core.listener.ImageLoadingListener;
import com.nostra13.universalimageloader.core.listener.SimpleImageLoadingListener;
import com.shishi.tech.paipai.R;

import java.io.File;

import jp.wasabeef.glide.transformations.MaskTransformation;
import jp.wasabeef.glide.transformations.RoundedCornersTransformation;
import log.LogManager;
import utils.common.StringUtils;

/**
 * ImageLoader 工具类
 */
public class ImageLoaderUtil {


    private static final String TAG = "ImageLoaderUtil";
    public static ImageLoader imageLoader = ImageLoader.getInstance();

    /**
     * 头像 Options
     */
    public static DisplayImageOptions userOptions = new DisplayImageOptions.Builder()
            .showImageOnLoading(R.drawable.icon_default_person)
            .showImageForEmptyUri(R.drawable.icon_default_person)
            .showImageOnFail(R.drawable.icon_default_person)
            .cacheInMemory(true)
            .cacheOnDisk(true)
            .considerExifParams(true)  //是否考虑JPEG图像EXIF参数（旋转，翻转）
            .imageScaleType(ImageScaleType.EXACTLY)//设置图片以如何的编码方式显示
            .bitmapConfig(Bitmap.Config.RGB_565)
            .build();

    /**
     * 群头像 Options
     */
    public static DisplayImageOptions groupHeadOptions = new DisplayImageOptions.Builder()
            .showImageOnLoading(R.drawable.icon_default_person)
            .showImageForEmptyUri(R.drawable.icon_default_person)
            .showImageOnFail(R.drawable.icon_default_person)
            .cacheInMemory(true)
            .cacheOnDisk(true)
            .considerExifParams(true)  //是否考虑JPEG图像EXIF参数（旋转，翻转）
            .imageScaleType(ImageScaleType.EXACTLY)//设置图片以如何的编码方式显示
            .bitmapConfig(Bitmap.Config.RGB_565)
            .build();


    /**
     * image 图片 Options
     */
    public static DisplayImageOptions imageOptions =
            new DisplayImageOptions.Builder()
            .showImageOnLoading(R.drawable.icon_default)
            .showImageForEmptyUri(R.drawable.icon_default)
            .showImageOnFail(R.drawable.icon_default)
            .cacheInMemory(true)
            .cacheOnDisk(true)
            .considerExifParams(true)  //是否考虑JPEG图像EXIF参数（旋转，翻转）
            .imageScaleType(ImageScaleType.EXACTLY)//设置图片以如何的编码方式显示
            .bitmapConfig(Bitmap.Config.RGB_565)
            .build();

    /**
     * image 本地图片 Options
     */
    public static DisplayImageOptions localImageOptions = new DisplayImageOptions.Builder()
            .showImageOnLoading(R.drawable.icon_default)
            .showImageForEmptyUri(R.drawable.icon_default)
            .showImageOnFail(R.drawable.icon_default)
            .cacheInMemory(true)
            .cacheOnDisk(true)
            .considerExifParams(true)  //是否考虑JPEG图像EXIF参数（旋转，翻转）
            .imageScaleType(ImageScaleType.IN_SAMPLE_INT)//设置图片以如何的编码方式显示
            .bitmapConfig(Bitmap.Config.RGB_565)
            .build();
    /**
     * image 视频 Options
     */
    public static DisplayImageOptions videoOptions = new DisplayImageOptions.Builder()
            .showImageOnLoading(R.drawable.icon_default_video)
            .showImageForEmptyUri(R.drawable.icon_default_video)
            .showImageOnFail(R.drawable.icon_default_video)
            .cacheInMemory(true)
            .cacheOnDisk(true)
            .considerExifParams(true)  //是否考虑JPEG图像EXIF参数（旋转，翻转）
            .imageScaleType(ImageScaleType.EXACTLY)//设置图片以如何的编码方式显示
            .bitmapConfig(Bitmap.Config.RGB_565)
            .build();

    /**
     * image 图片 Options
     */
    public static DisplayImageOptions imageOptionsChat = new DisplayImageOptions.Builder()
            .showImageOnLoading(R.drawable.icon_default)
            .showImageForEmptyUri(R.drawable.icon_default)
            .showImageOnFail(R.drawable.icon_default)
            .cacheInMemory(true)
            .cacheOnDisk(true)
            .considerExifParams(true)  //是否考虑JPEG图像EXIF参数（旋转，翻转）
            .imageScaleType(ImageScaleType.EXACTLY)//设置图片以如何的编码方式显示
            .bitmapConfig(Bitmap.Config.RGB_565)
            .build();


    /***
     * 配置 DisplayImageOptions
     *
     * @param loadingSrc
     * @param emptyUriSrc
     * @param failLoadSrc
     * @return
     */
    public static DisplayImageOptions getCommonOption(Integer loadingSrc, Integer emptyUriSrc,
                                                      Integer failLoadSrc) {
        DisplayImageOptions displyOptions = new DisplayImageOptions.Builder()
                .showImageOnLoading(null != loadingSrc ? loadingSrc : R.drawable.icon_default)
                .showImageForEmptyUri(null != emptyUriSrc ? emptyUriSrc : R.drawable.icon_default)
                .showImageOnFail(null != failLoadSrc ? failLoadSrc : R.drawable.icon_default).cacheInMemory(true)
                .cacheOnDisc(true).imageScaleType(ImageScaleType.EXACTLY).build();

        return displyOptions;
    }

    /***
     * 配置 DisplayImageOptions
     * @return
     */
    public static DisplayImageOptions getCommonOption() {
        DisplayImageOptions displyOptions = new DisplayImageOptions.Builder()
                .showImageOnLoading( R.drawable.icon_default)
                .showImageForEmptyUri( R.drawable.icon_default)
                .showImageOnFail( R.drawable.icon_default).cacheInMemory(true)
                .cacheOnDisc(true).imageScaleType(ImageScaleType.EXACTLY).build();

        return displyOptions;
    }


    /**
     * 可配置 DisplayImageOptions 显示图片
     *
     * @param imageView
     * @param imageUrl
     * @param options
     */
    public static void displayImage(ImageView imageView, String imageUrl, DisplayImageOptions options) {
        if (StringUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else {
            imageLoader.displayImage(displayUrl(imageUrl), imageView, options);
            imageView.setTag(imageUrl);
        }
    }


    /**
     * image 加载网络用户头像
     *
     * @param imageUrl
     * @param avatarView
     */
    public static void displayAvatar(String imageUrl, ImageView avatarView) {
        if (StringUtils.isEmpty(imageUrl)) {
            avatarView.setImageResource(R.drawable.icon_default_person);
        } else {
            imageLoader.displayImage(displayUrl(imageUrl), avatarView, userOptions);
            avatarView.setTag(imageUrl);
        }
    }

    /**
     * image 加载网络用户头像
     *
     * @param imageUrl
     * @param avatarView
     */
    public static void displayGroupAvatar(String imageUrl, ImageView avatarView) {
        if (StringUtils.isEmpty(imageUrl)) {
            avatarView.setImageResource(R.drawable.icon_default_person);
        } else {
            imageLoader.displayImage(displayUrl(imageUrl), avatarView, groupHeadOptions);
            avatarView.setTag(imageUrl);
        }
    }


    /**
     * imajge 加载网络图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayNetworkImage(ImageView imageView, String imageUrl) {
        if (StringUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else {
            //if (!imageUrl.equals(imageView.getTag())) {
            ImageAware imageAware = new ImageViewAware(imageView, false);
            imageLoader.displayImage(displayUrl(imageUrl), imageAware, imageOptions);
            imageView.setTag(imageUrl);
            //}
        }
    }


    /**
     * imajge 加载网络图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayNetworkChatImage(ImageView imageView, String imageUrl) {
        if (StringUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else {
            imageLoader.displayImage(displayUrl(imageUrl), imageView, imageOptionsChat);
        }
    }

    /**
     * imajge 加载网络视频缩图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayNetworkVideoImage(ImageView imageView, String imageUrl) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.com_bg_fff_r8);
            } else {
                imageLoader.displayImage(displayUrl(imageUrl), imageView, videoOptions, new SimpleImageLoadingListener() {
                    @Override
                    public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
                        ImageView imageView = (ImageView) view;
                        Context mContext = view.getContext();
                        imageView.setImageBitmap(PhotoUtil.toCutThumbnail(mContext, loadedImage));
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayNetworkImage 加载报错...");
        }
    }

    /***
     * 判断升级后 要自己组装 url 地址
     *
     * @param url
     * @return
     */
    public static String displayUrl(String url) {
        if (url == null)
            return "";
        if (!url.contains("http://") && !url.contains("file://")) {
            return SharedPreUtil.getInstance().getValue(SharedPreUtil.QINIU_URL) + "/" + url;
        } else {
            return url;
        }
    }

    /**
     * 去掉升级后的组装的域名(自定义表情没有域名)
     *
     * @return
     */
    public static String displaySimpleUrl(String url) {
        if (url == null)
            return "";
        if (url.contains("http://") || url.contains("file://")) {
            return url.replace(SharedPreUtil.getInstance().getValue(SharedPreUtil.QINIU_URL) + "/", "");
        } else {
            return url;
        }
    }

    /**
     * image 加载本地图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayLocalImage(ImageView imageView, String imageUrl) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.icon_default);
            } else {
                imageLoader.displayImage("file://" + imageUrl, imageView, localImageOptions);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLocalImage 加载报错...");
        }
    }

    /**
     * image 加载本地图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayLoadImage(ImageView imageView, String imageUrl) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.icon_default);
            } else {
                imageLoader.displayImage("file://" + imageUrl, imageView, imageOptions);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLoadImage 加载报错...");
        }
    }

    public static void loadImage(final ImageView imageView, final String imageUrl) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.icon_default);
            } else {
                imageLoader.loadImage("file://" + imageUrl, imageOptions, new SimpleImageLoadingListener() {
                    @Override
                    public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
                        super.onLoadingComplete(imageUri, view, loadedImage);
                        if (imageUrl.equals(imageView.getTag())) {
                            imageView.setImageBitmap(loadedImage);
                        }
                    }
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLoadImage 加载报错...");
        }
    }


    /**
     * 加载图片(本地或者网络图片)
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayImage(ImageView imageView, String imageUrl) {
        if (TextUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else if (imageUrl.contains(StaticVariable.DOMAIN_QINIU)) {//网络图片
            displayNetworkChatImage(imageView, imageUrl);
        } else {
            displayLoadChatImage(imageView, imageUrl);
        }
    }

    /**
     * 加载视频(本地或者网络)
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayVideo(ImageView imageView, String imageUrl) {
        if (TextUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.com_bg_fff_r8);
        } else if (imageUrl.contains(StaticVariable.DOMAIN_QINIU)) {//网络图片
            displayNetworkVideoImage(imageView, imageUrl);
        } else {
            displayLocalVideoImage(imageView, imageUrl);
        }
    }

    /**
     * image 加载本地视频
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayLocalVideoImage(ImageView imageView, String imageUrl) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.icon_default);
            } else {
                imageLoader.displayImage("file://" + imageUrl, imageView, imageOptionsChat);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLoadImage 加载报错...");
        }
    }

    /**
     * image 加载本地图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayLoadChatImage(ImageView imageView, String imageUrl) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.icon_default);
            } else {
                imageLoader.displayImage("file://" + imageUrl, imageView, imageOptionsChat);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLoadImage 加载报错...");
        }
    }

    /**
     * image 加载本地图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayLoadImage(String imageUrl, ImageView imageView, ImageLoadingListener listener) {
        try {
            if (StringUtils.isEmpty(imageUrl)) {
                imageView.setImageResource(R.drawable.icon_default);
            } else {
                imageLoader.displayImage("file://" + imageUrl, imageView, imageOptions, listener);
            }
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLoadImage 加载报错...");
        }
    }

    /**
     * image 加载Drawable 图片
     *
     * @param imageView
     * @param imageUrl
     */
    public static void displayLoadImage(ImageView imageView, int imageUrl) {
        try {
            imageLoader.displayImage("drawable://" + imageUrl, imageView, imageOptions);
        } catch (Exception e) {
            e.printStackTrace();
            LogManager.getLogger().e(TAG, "displayLoadImage 加载报错...");
        }
    }


    /******************************************************************************************
     *                                              Glide imageLoader
     ******************************************************************************************/


    /**
     * 显示头像
     *
     * @param imageUrl
     * @param avatarView
     */
    public static void displayGlideAvatar(Context context, String imageUrl, ImageView avatarView) {
        displayGlideAvatar(context, imageUrl, avatarView, R.drawable.icon_default_person);
    }

    /**
     * 显示头像
     *
     * @param imageUrl
     * @param avatarView
     * @param imgId      默认加载的图片
     */
    public static void displayGlideAvatar(Context context, final String imageUrl, final ImageView avatarView, int imgId) {
        if (StringUtils.isEmpty(imageUrl)) {
            avatarView.setImageResource(imgId);
        } else {
           GlideDrawableImageViewTarget viewTarget = new GlideDrawableImageViewTarget(avatarView);
            Glide.with(context).load(imageUrl)
                    //.skipMemoryCache(true)
                    .diskCacheStrategy(DiskCacheStrategy.SOURCE)
                    .bitmapTransform(new RoundedCornersTransformation(context, 8, 0,
                            RoundedCornersTransformation.CornerType.ALL))
                    .error(imgId)
                    .crossFade()
                    .into(viewTarget);
        }
    }

    /**
     * 显示头像
     *
     * @param imageUrl
     * @param avatarView
     * @param imgId      默认加载的图片
     * @param bgId      加载图片的背景框
     */
    public static void displayGlideAvatar(Context context, final String imageUrl, final ImageView avatarView, int imgId, int bgId) {
        if (StringUtils.isEmpty(imageUrl)) {
            avatarView.setImageResource(imgId);
        } else {
            GlideDrawableImageViewTarget viewTarget = new GlideDrawableImageViewTarget(avatarView);
            Glide.with(context).load(imageUrl)
                    //.skipMemoryCache(true)
                    .diskCacheStrategy(DiskCacheStrategy.SOURCE)
                    .bitmapTransform(new RoundedCornersTransformation(context, 8, 0,
                            RoundedCornersTransformation.CornerType.ALL), new MaskTransformation(context, bgId))
                    .error(imgId)
                    .crossFade()
                    .into(viewTarget);
        }
    }

    /**
     *  需要加载完成后做处理调用
     * @param context
     * @param imageUrl
     * @param imageView
     * @param target ImageViewTarget
     */
    public static void displayGlideNetworkImage(Context context, String imageUrl, ImageView imageView, ImageViewTarget target){
        if (StringUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else {
             /*if (!"gif".equals(FileUtil.getFileExtension(imageUrl)) && imageUrl.contains(StaticVariable.DOMAIN_QINIU)) {//非gif网络图，加上七牛参数
               imageUrl += "?imageMogr2/auto-orient/thumbnail/350000@";//生成图的像素总数小于指定值
            }*/
            LogManager.getLogger().i("Local",imageUrl);
            Glide.with(context)
                    .load(imageUrl)
                    .diskCacheStrategy(DiskCacheStrategy.SOURCE)
                    .error(R.drawable.icon_default)
                    .crossFade()
                    .into(target);
        }
    }


    /**
     * Glide加载网络图片
     *
     * @param context
     * @param imageUrl
     * @param imageView
     */
    public static void displayGlideNetworkImage(Context context, ImageView imageView, String imageUrl) {
        if (StringUtils.isEmpty(imageUrl)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else {
            LogManager.getLogger().i("Glide===>加载网络图片", imageUrl);
            Glide.with(context)
                    .load(imageUrl)
                    .diskCacheStrategy(DiskCacheStrategy.SOURCE)
                    .error(R.drawable.icon_default)
                    .crossFade()
                    .into(imageView);
        }
    }

    /**
     * Glide加载本地图片
     *
     * @param context
     * @param imagePath
     * @param imageView
     */
    public static void displayGlideLocalImage(Context context, ImageView imageView, String imagePath) {
        if (StringUtils.isEmpty(imagePath)) {
            imageView.setImageResource(R.drawable.icon_default);
        } else {
            LogManager.getLogger().i("Glide===>加载本地图片", imagePath);
            Glide.with(context)
                    .load(new File(imagePath))
                    .diskCacheStrategy(DiskCacheStrategy.SOURCE)
                    .error(R.drawable.icon_default)
                    .crossFade()
                    .into(imageView);
        }
    }

    /** 滑动停止时，调用resumeRequests()恢复请求 */

    public static void resumeRequests(Context context) {
        Glide.with(context).resumeRequests();
    }

    /** 当列表在滑动的时候，调用pauseRequests()取消请求 */
    public static void pauseRequests(Context context) {
        Glide.with(context).pauseRequests();
    }
}
